Tuning the Geometry Subsystem

A number of optimizations are possible for the geometry subsystem:

• "Using Peak-Performance Primitives"

• "Using Vertex Arrays"

• "Using Drawing Modes Appropriately"

• "Optimizing Lighting Performance"

• "Advanced Geometry-Limited Tuning Techniques"

Using Peak-Performance Primitives

This section describes how to draw geometry with optimal primitives. Consider these guidelines to optimize drawing:

• Use connected primitives (line strips, triangle strips, triangle fans, and quad strips).

  Connected primitives are desirable because they reduce the amount of data and the amount of per-polygon or per-edge work done by OpenGL.

• Use "well-behaved" polygons--convex and planar, with only three or four vertices.

  Concave and self-intersecting polygons must be tessellated by GLU before they can be drawn, and are therefore prohibitively expensive. Nonplanar polygons and polygons with large numbers of vertices are more likely to exhibit shading artifacts.

  If your database has polygons that are not well-behaved, perform an initial one-time pass over the database to change the troublemakers into well-behaved polygons and use the new database for rendering. You can store the results in OpenGL display lists. Using connected primitives results in additional gains.

• Minimize the data sent per vertex.

  Polygon rates can be affected directly by the number of normals or colors sent per polygon. Setting a color or normal per vertex, regardless of the glShadeModel() used, may be slower than setting only a color per polygon, because of the time spent sending the extra data and resetting the current color. The number of normals and colors per polygon also directly affects the size of a display list containing the object.

• If your model has backfacing surfaces that can be culled using the normals, send a normal/vertex, even if you do not have lighting enabled (see "The Object Space Vertex Culling Extension").

• Group like primitives and minimize state changes to reduce pipeline revalidation.

• Use normalized normals.

• Avoid non-uniform scaling operations.

Using Vertex Arrays

Vertex arrays are available in OpenGL 1.1 (see "OpenGL 1.1 Vertex Arrays"). They offer the following benefits:

• The OpenGL implementation can take advantage of uniform data formats.

• The glInterleavedArrays() call lets you specify packed vertex data easily. Packed vertex formats are typically faster for OpenGL to process.

• The glDrawArrays() call reduces subroutine call overhead.

• The glDrawElements() call reduces subroutine call overhead and also reduces per-vertex calculations because vertices are reused. The lock/unlock call can further reduce per-vertex calculations.

One possible disadvantage to vertex arrays over using glBegin()/glEnd() is that it may require additional memory usage.

If you use glBegin()/glEnd() instead of glDrawArrays() or glDrawElements() calls, put as many vertices as possible between the glBegin() and the glEnd(). This amortizes the cost of the call and also makes it easier to batch vertices.

Note that in situations where vertices are shared, it makes sense to lock them down for optimum performance. See "The Compiled Vertex Arrays Extension."

Using Drawing Modes Appropriately

This section discusses ways of reducing per-vertex costs.

Using Fast Drawing Modes

For optimum performance, use flat shading whenever possible. This reduces the number of lighting computations from one per vertex to one per primitive, and also reduces the amount of data that must be processed for each primitive. This is particularly important for high-performance line drawing.

Using Expensive Modes Efficiently

OpenGL offers many features that create sophisticated effects with excellent performance. However, these features have some performance cost, compared to drawing the same scene without them. Use these features only where their effects, performance, and quality are justified.

• Turn off features when they are not required.

  Once a feature has been turned on, it can slow the transform rate even when it has no visible effect.

  For example, the use of fog can slow the transform rate of polygons even when the polygons are too close to show fog, and even when the fog density is set to zero. For these conditions, turn off fog explicitly with

  glDisable(GL_FOG)

• Minimize expensive mode changes. Sort operations by the most expensive mode. Specifically, consider these tips:

  • Use small numbers of texture maps to avoid the cost of switching between textures. If you have many small textures, consider combining them into a single larger, tiled texture. Rather than switching to a new texture before drawing a textured polygon, choose texture coordinates that select the appropriate small texture tile within the large texture.

  • Avoid changing the projection matrix or changing glDepthRange() parameters.

  • When fog is enabled, avoid changing fog parameters.

  • Turn fog off for rendering with a different projection (for example, orthographic) and turn it back on when returning to the normal projection.

• Beware of excessive mode changes, even mode changes considered cheap, such as changes to shade model, depth buffering, and blending functions.

• When you do need to change state, consider using glPushAttrib()/glPopAttrib(); it is sometimes faster.

Optimizing Lighting Performance

OpenGL offers a large selection of lighting features: The penalties some features carry may vary depending on the hardware you're running on. Be prepared to experiment with the lighting configuration.

As a general rule, use the simplest possible lighting model, a single infinite light with an infinite viewer. For some local effects, try replacing local lights with infinite lights and a local viewer.

Use the following settings for peak performance lighting:

• single infinite light

• nonlocal viewing--GL_LIGHT_MODEL_LOCAL_VIEWER set to GL_FALSE in glLightModel() (the default)

• single-sided lighting--GL_LIGHT_MODEL_TWO_SIDE set to GL_FALSE in glLightModel() (the default)

• GL_COLOR_MATERIAL or GL_INDEX_MATERIAL_SGI disabled

• GL_NORMALIZE disabled--because this is usually necessary when the model-view matrix includes a scaling transformation, consider preprocessing the scene to eliminate scaling.

In addition, follow these guidelines to achieve peak lighting performance:

• Avoid using local lights.

  Local lights are noticeably more expensive than infinite lights.

• Don't change material parameters frequently.

  Changing material parameters can be expensive. If you need to change the material parameters many times per frame, consider rearranging the scene traversal to minimize material changes. Also consider using glColorMaterial() or glIndexMaterialSGI() to change specific parameters automatically, rather than using glMaterial() to change parameters explicitly.

  The following code fragment illustrates how to change ambient and diffuse material parameters at every polygon or at every vertex:

  glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);

  glEnable(GL_COLOR_MATERIAL);

  ...

  /* Set ambient and diffuse material parameters: */

  glColor4f(red, green, blue, alpha);

  /* Draw triangles: */

  glBegin(GL_TRIANGLES);

  ...

  glEnd();

• Local viewing: Setting GL_LIGHT_MODEL_LOCAL_VIEWER to GL_TRUE with glLightModel(), while using infinite lights only, reduces performance by a small amount. However, each additional local light noticeably degrades the transform rate.

• Two-sided lighting illuminates both sides of a polygon. This is much faster than the alternative of drawing polygons twice. However, using two-sided lighting is significantly slower than one-sided lighting for a single rendering of an object.

• Use unit-length normals.

• Avoid scaling operations if possible.

• Avoid changing the GL_SHININESS material parameter if possible. Setting a new GL_SHININESS value requires significant computation each time.

• Avoid using lighting calls inside a glBegin()/glEnd() sequence.

• If possible, avoid calls to glMaterial() during a glBegin()/glEnd() drawing sequence, as this has a serious performance impact. While making such calls to change colors by changing material properties is possible, the performance penalty makes it unadvisable. Use glColorMaterial() or glIndexMaterialSGI() instead.

Advanced Geometry-Limited Tuning Techniques

This section describes advanced techniques for tuning transform-limited drawing. Follow these guidelines to draw objects with complex surface characteristics:

• Use glAlphaFunc() in conjunction with one or more textures to give the effect of rather complex geometry on a single polygon.

  Consider drawing an image of a complex object by texturing it onto a single polygon. Set alpha values to zero in the texture outside the image of the object. (The edges of the object can be antialiased by using alpha values between zero and one.) Orient the polygon to face the viewer. To prevent pixels with zero alpha values in the textured polygon from being drawn, call

  glAlphaFunc(GL_NOTEQUAL, 0.0)

  This effect is often used to create objects like trees that have complex edges or many holes through which the background should be visible (or both), such as trees.

• Eliminate objects or polygons that will be out of sight or too small to see.

• Use fog to increase visual detail without drawing small background objects.

Using Peak-Performance Primitives

Using Vertex Arrays

Using Drawing Modes Appropriately

Using Fast Drawing Modes

Using Expensive Modes Efficiently

Optimizing Lighting Performance

Advanced Geometry-Limited Tuning Techniques